package com.ms.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ms.dao.EventMapper;
import com.ms.dao.RegistrationMapper;
import com.ms.entity.Event;
import com.ms.entity.Registration;
import com.ms.entity.User;
import com.ms.service.inter.EventService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 比赛服务实现类 - 实现EventService接口
 */
@Service
@Transactional
public class EventServiceImpl extends ServiceImpl<EventMapper, Event> implements EventService {

    @Autowired
    private EventMapper eventMapper;
    
    @Autowired
    private RegistrationMapper registrationMapper;

    /**
     * 根据比赛ID查找比赛
     * @param eventID 比赛ID
     * @return 比赛对象
     */
    @Override
    public Event findById(String eventID) {
        try {
            return eventMapper.selectById(eventID);
        } catch (Exception e) {
            throw new RuntimeException("根据ID查找比赛失败: " + e.getMessage(), e);
        }
    }

    /**
     * 获取所有比赛
     * @return 比赛列表
     */
    @Override
    public List<Event> findAll() {
        try {
            return eventMapper.selectAll();
        } catch (Exception e) {
            throw new RuntimeException("获取所有比赛失败: " + e.getMessage(), e);
        }
    }

    /**
     * 根据类别获取比赛
     * @param category 比赛类别
     * @return 比赛列表
     */
    @Override
    public List<Event> findByCategory(String category) {
        try {
            return eventMapper.selectByCategory(category);
        } catch (Exception e) {
            throw new RuntimeException("根据类别获取比赛失败: " + e.getMessage(), e);
        }
    }

    /**
     * 根据比赛ID获取所有项目
     * @param gameID 比赛ID
     * @return 项目列表
     */
    @Override
    public List<Event> findByGameId(String gameID) {
        try {
            return eventMapper.selectByGameId(gameID);
        } catch (Exception e) {
            throw new RuntimeException("根据比赛ID获取项目失败: " + e.getMessage(), e);
        }
    }

    /**
     * 保存比赛项目
     * @param event 比赛项目对象
     * @return 是否保存成功
     */
    @Override
    public boolean saveEvent(Event event) {
        try {
            // 设置默认状态为"进行中"
            if (event.getStatus() == null || event.getStatus().isEmpty()) {
                event.setStatus("进行中");
            }
            
            // 设置当前参与人数为0
            if (event.getCurrentParticipants() == null) {
                event.setCurrentParticipants(0);
            }
            
            if (event.getEventID() != null) {
                // 更新操作
                return eventMapper.updateById(event) > 0;
            } else {
                // 新增操作
                return eventMapper.insert(event) > 0;
            }
        } catch (Exception e) {
            throw new RuntimeException("保存比赛项目失败: " + e.getMessage(), e);
        }
    }





    /**
     * 检查用户是否已报名某比赛
     * @param userID 用户ID
     * @param eventID 比赛ID
     * @return 是否已报名
     */
    @Override
    public boolean isUserRegistered(String userID, String eventID) {
        try {
            int count = eventMapper.checkUserRegistration(userID, eventID);
            return count > 0;
        } catch (Exception e) {
            throw new RuntimeException("检查用户报名状态失败: " + e.getMessage(), e);
        }
    }

    /**
     * 用户报名比赛
     * @param userID 用户ID
     * @param eventID 比赛ID
     * @return 报名结果
     */
    @Override
    @Transactional
    public boolean registerUserForEvent(String userID, String eventID) {
        try {
            // 先检查比赛是否存在且有名额
            Event event = eventMapper.selectById(eventID);
            if (event == null) {
                throw new RuntimeException("比赛不存在");
            }
            if (event.getCurrentParticipants() >= event.getMaxParticipants()) {
                throw new RuntimeException("比赛名额已满");
            }

            // 执行报名操作
            int result = eventMapper.registerUserForEvent(userID, eventID);
            if (result > 0) {
                // 增加比赛当前参与人数
                eventMapper.increaseParticipants(eventID);
            }
            return result > 0;
        } catch (Exception e) {
            throw new RuntimeException("报名比赛失败: " + e.getMessage(), e);
        }
    }

    /**
     * 用户取消报名
     * @param userID 用户ID
     * @param eventID 比赛ID
     * @return 取消结果
     */
    @Override
    @Transactional
    public boolean cancelRegistration(String userID, String eventID) {
        try {
            int result = eventMapper.cancelRegistration(userID, eventID);
            if (result > 0) {
                // 减少比赛当前参与人数
                eventMapper.decreaseParticipants(eventID);
            }
            return result > 0;
        } catch (Exception e) {
            throw new RuntimeException("取消报名失败: " + e.getMessage(), e);
        }
    }

    /**
     * 获取用户报名的所有比赛
     * @param userID 用户ID
     * @return 比赛列表
     */
    @Override
    public List<Event> findEventsByUserId(String userID) {
        try {
            return eventMapper.selectEventsByUserId(userID);
        } catch (Exception e) {
            throw new RuntimeException("获取用户报名比赛失败: " + e.getMessage(), e);
        }
    }

    /**
     * 删除比赛项目
     * @param eventID 比赛项目ID
     * @return 是否删除成功
     */
    @Override
    public boolean deleteEvent(Integer eventID) {
        try {
            // 检查比赛项目是否存在
            Event event = eventMapper.selectById(eventID);
            if (event == null) {
                throw new RuntimeException("比赛项目不存在");
            }
            
            // 删除比赛项目
            return eventMapper.deleteById(eventID) > 0;
        } catch (Exception e) {
            throw new RuntimeException("删除比赛项目失败: " + e.getMessage(), e);
        }
    }
    
    /**
     * 根据比赛项目ID获取所有报名信息及用户信息
     * @param eventID 比赛项目ID
     * @return 报名信息列表，包含用户详细信息
     */
    @Override
    public List<Map<String, Object>> getRegistrationsWithUserInfo(String eventID) {
        try {
            // 获取比赛项目的所有报名信息（包括状态为0和1的记录）
            List<Registration> registrations = registrationMapper.selectByEventId(eventID);
            
            // 构建包含用户信息的结果列表
            List<Map<String, Object>> result = new ArrayList<>();
            
            // 遍历报名信息，获取对应的用户信息
            for (Registration registration : registrations) {
                Map<String, Object> registrationInfo = new HashMap<>();
                
                // 添加报名信息
                registrationInfo.put("registration", registration);
                
                // 根据用户ID获取用户详细信息
                User user = registrationMapper.selectUserById(registration.getUserID());
                registrationInfo.put("user", user);
                
                result.add(registrationInfo);
            }
            
            return result;
        } catch (Exception e) {
            throw new RuntimeException("获取报名信息及用户信息失败: " + e.getMessage(), e);
        }
    }
    
    /**
     * 根据主办方ID获取所有比赛及其项目信息
     * @param organizerId 主办方ID
     * @return 比赛及项目信息列表
     */
    @Override
    public List<Map<String, Object>> getGamesAndEventsByOrganizerId(Integer organizerId) {
        try {
            // 获取主办方的所有比赛
            List<Map<String, Object>> games = eventMapper.selectGamesByOrganizerId(organizerId);
            
            // 为每个比赛获取其项目列表
            for (Map<String, Object> game : games) {
                Integer gameId = (Integer) game.get("games_id");
                List<Map<String, Object>> events = eventMapper.selectEventsByGameIdSimple(gameId);
                game.put("events", events);
            }
            
            return games;
        } catch (Exception e) {
            throw new RuntimeException("获取主办方比赛及项目信息失败: " + e.getMessage(), e);
        }
    }
}